home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / C / Applications / Flex-CW 2.5.1 / misc.c < prev    next >
Text File  |  1995-10-10  |  16KB  |  896 lines
  1. /* misc - miscellaneous flex routines */
  2.  
  3. /*-
  4.  * Copyright (c) 1990 The Regents of the University of California.
  5.  * All rights reserved.
  6.  *
  7.  * This code is derived from software contributed to Berkeley by
  8.  * Vern Paxson.
  9.  * 
  10.  * The United States Government has rights in this work pursuant
  11.  * to contract no. DE-AC03-76SF00098 between the United States
  12.  * Department of Energy and the University of California.
  13.  *
  14.  * Redistribution and use in source and binary forms are permitted provided
  15.  * that: (1) source distributions retain this entire copyright notice and
  16.  * comment, and (2) distributions including binaries display the following
  17.  * acknowledgement:  ``This product includes software developed by the
  18.  * University of California, Berkeley and its contributors'' in the
  19.  * documentation or other materials provided with the distribution and in
  20.  * all advertising materials mentioning features or use of this software.
  21.  * Neither the name of the University nor the names of its contributors may
  22.  * be used to endorse or promote products derived from this software without
  23.  * specific prior written permission.
  24.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
  25.  * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
  26.  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  27.  */
  28.  
  29. /* $Header: /home/daffy/u0/vern/flex/RCS/misc.c,v 2.44 95/03/04 16:11:59 vern Exp $ */
  30.  
  31. #include "flexdef.h"
  32.  
  33.  
  34.  
  35. /* declare functions that have forward references */
  36.  
  37. /* void dataflush PROTO((void)); */
  38. int otoi PROTO((Char []));
  39.  
  40.  
  41. void action_define( defname, value )
  42. char *defname;
  43. int value;
  44.     {
  45.     char buf[MAXLINE];
  46.  
  47.     if ( strlen( defname ) > MAXLINE / 2 )
  48.         {
  49.         format_pinpoint_message( _( "name \"%s\" ridiculously long" ), 
  50.             defname );
  51.         return;
  52.         }
  53.  
  54.     sprintf( buf, "#define %s %d\n", defname, value );
  55.     add_action( buf );
  56.     }
  57.  
  58.  
  59. void add_action( new_text )
  60. char *new_text;
  61.     {
  62.     int len = strlen( new_text );
  63.  
  64.     while ( len + action_index >= action_size - 10 /* slop */ )
  65.         {
  66.         int new_size = action_size * 2;
  67.  
  68.         if ( new_size <= 0 )
  69.             /* Increase just a little, to try to avoid overflow
  70.              * on 16-bit machines.
  71.              */
  72.             action_size += action_size / 8;
  73.         else
  74.             action_size = new_size;
  75.  
  76.         action_array =
  77.             reallocate_character_array( action_array, action_size );
  78.         }
  79.  
  80.     strcpy( &action_array[action_index], new_text );
  81.  
  82.     action_index += len;
  83.     }
  84.  
  85.  
  86. /* allocate_array - allocate memory for an integer array of the given size */
  87.  
  88. void *allocate_array( size, element_size )
  89. int size;
  90. size_t element_size;
  91.     {
  92.     register void *mem;
  93.     size_t num_bytes = element_size * size;
  94.  
  95.     mem = flex_alloc( num_bytes );
  96.     if ( ! mem )
  97.         flexfatal(
  98.             _( "memory allocation failed in allocate_array()" ) );
  99.  
  100.     return mem;
  101.     }
  102.  
  103.  
  104. /* all_lower - true if a string is all lower-case */
  105.  
  106. int all_lower( str )
  107. register char *str;
  108.     {
  109.     while ( *str )
  110.         {
  111.         if ( ! isascii( (Char) *str ) || ! islower( *str ) )
  112.             return 0;
  113.         ++str;
  114.         }
  115.  
  116.     return 1;
  117.     }
  118.  
  119.  
  120. /* all_upper - true if a string is all upper-case */
  121.  
  122. int all_upper( str )
  123. register char *str;
  124.     {
  125.     while ( *str )
  126.         {
  127.         if ( ! isascii( (Char) *str ) || ! isupper( *str ) )
  128.             return 0;
  129.         ++str;
  130.         }
  131.  
  132.     return 1;
  133.     }
  134.  
  135.  
  136. /* bubble - bubble sort an integer array in increasing order
  137.  *
  138.  * synopsis
  139.  *   int v[n], n;
  140.  *   void bubble( v, n );
  141.  *
  142.  * description
  143.  *   sorts the first n elements of array v and replaces them in
  144.  *   increasing order.
  145.  *
  146.  * passed
  147.  *   v - the array to be sorted
  148.  *   n - the number of elements of 'v' to be sorted
  149.  */
  150.  
  151. void bubble( v, n )
  152. int v[], n;
  153.     {
  154.     register int i, j, k;
  155.  
  156.     for ( i = n; i > 1; --i )
  157.         for ( j = 1; j < i; ++j )
  158.             if ( v[j] > v[j + 1] )    /* compare */
  159.                 {
  160.                 k = v[j];    /* exchange */
  161.                 v[j] = v[j + 1];
  162.                 v[j + 1] = k;
  163.                 }
  164.     }
  165.  
  166.  
  167. /* check_char - checks a character to make sure it's within the range
  168.  *        we're expecting.  If not, generates fatal error message
  169.  *        and exits.
  170.  */
  171.  
  172. void check_char( c )
  173. int c;
  174.     {
  175.     if ( c >= CSIZE )
  176.         lerrsf( _( "bad character '%s' detected in check_char()" ),
  177.             readable_form( c ) );
  178.  
  179.     if ( c >= csize )
  180.         lerrsf(
  181.         _( "scanner requires -8 flag to use the character %s" ),
  182.             readable_form( c ) );
  183.     }
  184.  
  185.  
  186.  
  187. /* clower - replace upper-case letter to lower-case */
  188.  
  189. Char clower( c )
  190. register int c;
  191.     {
  192.     return (Char) ((isascii( c ) && isupper( c )) ? tolower( c ) : c);
  193.     }
  194.  
  195.  
  196. /* copy_string - returns a dynamically allocated copy of a string */
  197.  
  198. char *copy_string( str )
  199. register const char *str;
  200.     {
  201.     register const char *c1;
  202.     register char *c2;
  203.     char *copy;
  204.     unsigned int size;
  205.  
  206.     /* find length */
  207.     for ( c1 = str; *c1; ++c1 )
  208.         ;
  209.  
  210.     size = (c1 - str + 1) * sizeof( char );
  211.     copy = (char *) flex_alloc( size );
  212.  
  213.     if ( copy == NULL )
  214.         flexfatal( _( "dynamic memory failure in copy_string()" ) );
  215.  
  216.     for ( c2 = copy; (*c2++ = *str++) != 0; )
  217.         ;
  218.  
  219.     return copy;
  220.     }
  221.  
  222.  
  223. /* copy_unsigned_string -
  224.  *    returns a dynamically allocated copy of a (potentially) unsigned string
  225.  */
  226.  
  227. Char *copy_unsigned_string( str )
  228. register Char *str;
  229.     {
  230.     register Char *c;
  231.     Char *copy;
  232.  
  233.     /* find length */
  234.     for ( c = str; *c; ++c )
  235.         ;
  236.  
  237.     copy = allocate_Character_array( c - str + 1 );
  238.  
  239.     for ( c = copy; (*c++ = *str++) != 0; )
  240.         ;
  241.  
  242.     return copy;
  243.     }
  244.  
  245.  
  246. /* cshell - shell sort a character array in increasing order
  247.  *
  248.  * synopsis
  249.  *
  250.  *   Char v[n];
  251.  *   int n, special_case_0;
  252.  *   cshell( v, n, special_case_0 );
  253.  *
  254.  * description
  255.  *   Does a shell sort of the first n elements of array v.
  256.  *   If special_case_0 is true, then any element equal to 0
  257.  *   is instead assumed to have infinite weight.
  258.  *
  259.  * passed
  260.  *   v - array to be sorted
  261.  *   n - number of elements of v to be sorted
  262.  */
  263.  
  264. void cshell( v, n, special_case_0 )
  265. Char v[];
  266. int n, special_case_0;
  267.     {
  268.     int gap, i, j, jg;
  269.     Char k;
  270.  
  271.     for ( gap = n / 2; gap > 0; gap = gap / 2 )
  272.         for ( i = gap; i < n; ++i )
  273.             for ( j = i - gap; j >= 0; j = j - gap )
  274.                 {
  275.                 jg = j + gap;
  276.  
  277.                 if ( special_case_0 )
  278.                     {
  279.                     if ( v[jg] == 0 )
  280.                         break;
  281.  
  282.                     else if ( v[j] != 0 && v[j] <= v[jg] )
  283.                         break;
  284.                     }
  285.  
  286.                 else if ( v[j] <= v[jg] )
  287.                     break;
  288.  
  289.                 k = v[j];
  290.                 v[j] = v[jg];
  291.                 v[jg] = k;
  292.                 }
  293.     }
  294.  
  295.  
  296. /* dataend - finish up a block of data declarations */
  297.  
  298. void dataend()
  299.     {
  300.     if ( datapos > 0 )
  301.         dataflush();
  302.  
  303.     /* add terminator for initialization; { for vi */
  304.     outn( "    } ;\n" );
  305.  
  306.     dataline = 0;
  307.     datapos = 0;
  308.     }
  309.  
  310.  
  311. /* dataflush - flush generated data statements */
  312.  
  313. void dataflush()
  314.     {
  315.     outc( '\n' );
  316.  
  317.     if ( ++dataline >= NUMDATALINES )
  318.         {
  319.         /* Put out a blank line so that the table is grouped into
  320.          * large blocks that enable the user to find elements easily.
  321.          */
  322.         outc( '\n' );
  323.         dataline = 0;
  324.         }
  325.  
  326.     /* Reset the number of characters written on the current line. */
  327.     datapos = 0;
  328.     }
  329.  
  330.  
  331. /* flexerror - report an error message and terminate */
  332.  
  333. void flexerror( msg )
  334. const char msg[];
  335.     {
  336.     fprintf( stderr, "%s: %s\n", program_name, msg );
  337.     flexend( 1 );
  338.     }
  339.  
  340.  
  341. /* flexfatal - report a fatal error message and terminate */
  342.  
  343. void flexfatal( msg )
  344. const char msg[];
  345.     {
  346.     fprintf( stderr, _( "%s: fatal internal error, %s\n" ),
  347.         program_name, msg );
  348.     exit( 1 );
  349.     }
  350.  
  351.  
  352. /* htoi - convert a hexadecimal digit string to an integer value */
  353.  
  354. int htoi( str )
  355. Char str[];
  356.     {
  357.     unsigned int result;
  358.  
  359.     (void) sscanf( (char *) str, "%x", &result );
  360.  
  361.     return result;
  362.     }
  363.  
  364.  
  365. /* lerrif - report an error message formatted with one integer argument */
  366.  
  367. void lerrif( msg, arg )
  368. const char msg[];
  369. int arg;
  370.     {
  371.     char errmsg[MAXLINE];
  372.     (void) sprintf( errmsg, msg, arg );
  373.     flexerror( errmsg );
  374.     }
  375.  
  376.  
  377. /* lerrsf - report an error message formatted with one string argument */
  378.  
  379. void lerrsf( msg, arg )
  380. const char msg[], arg[];
  381.     {
  382.     char errmsg[MAXLINE];
  383.  
  384.     (void) sprintf( errmsg, msg, arg );
  385.     flexerror( errmsg );
  386.     }
  387.  
  388.  
  389. /* line_directive_out - spit out a "#line" statement */
  390.  
  391. void line_directive_out( output_file, do_infile )
  392. FILE *output_file;
  393. int do_infile;
  394.     {
  395.     char directive[MAXLINE], filename[MAXLINE];
  396.     char *s1, *s2, *s3;
  397.     static char line_fmt[] = "#line %d \"%s\"\n";
  398.  
  399.     if ( ! gen_line_dirs )
  400.         return;
  401.  
  402.     if ( (do_infile && ! infilename) || (! do_infile && ! outfilename) )
  403.         /* don't know the filename to use, skip */
  404.         return;
  405.  
  406.     s1 = do_infile ? infilename : outfilename;
  407.     s2 = filename;
  408.     s3 = &filename[sizeof( filename ) - 2];
  409.  
  410.     while ( s2 < s3 && *s1 )
  411.         {
  412.         if ( *s1 == '\\' )
  413.             /* Escape the '\' */
  414.             *s2++ = '\\';
  415.  
  416.         *s2++ = *s1++;
  417.         }
  418.  
  419.     *s2 = '\0';
  420.  
  421.     if ( do_infile )
  422.         sprintf( directive, line_fmt, linenum, filename );
  423.     else
  424.         {
  425.         if ( output_file == stdout )
  426.             /* Account for the line directive itself. */
  427.             ++out_linenum;
  428.  
  429.         sprintf( directive, line_fmt, out_linenum, filename );
  430.         }
  431.  
  432.     /* If output_file is nil then we should put the directive in
  433.      * the accumulated actions.
  434.      */
  435.     if ( output_file )
  436.         {
  437.         fputs( directive, output_file );
  438.         }
  439.     else
  440.         add_action( directive );
  441.     }
  442.  
  443.  
  444. /* mark_defs1 - mark the current position in the action array as
  445.  *               representing where the user's section 1 definitions end
  446.  *         and the prolog begins
  447.  */
  448. void mark_defs1()
  449.     {
  450.     defs1_offset = 0;
  451.     action_array[action_index++] = '\0';
  452.     action_offset = prolog_offset = action_index;
  453.     action_array[action_index] = '\0';
  454.     }
  455.  
  456.  
  457. /* mark_prolog - mark the current position in the action array as
  458.  *               representing the end of the action prolog
  459.  */
  460. void mark_prolog()
  461.     {
  462.     action_array[action_index++] = '\0';
  463.     action_offset = action_index;
  464.     action_array[action_index] = '\0';
  465.     }
  466.  
  467.  
  468. /* mk2data - generate a data statement for a two-dimensional array
  469.  *
  470.  * Generates a data statement initializing the current 2-D array to "value".
  471.  */
  472. void mk2data( value )
  473. int value;
  474.     {
  475.     if ( datapos >= NUMDATAITEMS )
  476.         {
  477.         outc( ',' );
  478.         dataflush();
  479.         }
  480.  
  481.     if ( datapos == 0 )
  482.         /* Indent. */
  483.         out( "    " );
  484.  
  485.     else
  486.         outc( ',' );
  487.  
  488.     ++datapos;
  489.  
  490.     out_dec( "%5d", value );
  491.     }
  492.  
  493.  
  494. /* mkdata - generate a data statement
  495.  *
  496.  * Generates a data statement initializing the current array element to
  497.  * "value".
  498.  */
  499. void mkdata( value )
  500. int value;
  501.     {
  502.     if ( datapos >= NUMDATAITEMS )
  503.         {
  504.         outc( ',' );
  505.         dataflush();
  506.         }
  507.  
  508.     if ( datapos == 0 )
  509.         /* Indent. */
  510.         out( "    " );
  511.     else
  512.         outc( ',' );
  513.  
  514.     ++datapos;
  515.  
  516.     out_dec( "%5d", value );
  517.     }
  518.  
  519.  
  520. /* myctoi - return the integer represented by a string of digits */
  521.  
  522. int myctoi( array )
  523. char array[];
  524.     {
  525.     int val = 0;
  526.  
  527.     (void) sscanf( array, "%d", &val );
  528.  
  529.     return val;
  530.     }
  531.  
  532.  
  533. /* myesc - return character corresponding to escape sequence */
  534.  
  535. Char myesc( array )
  536. Char array[];
  537.     {
  538.     Char c, esc_char;
  539.  
  540.     switch ( array[1] )
  541.         {
  542.         case 'b': return '\b';
  543.         case 'f': return '\f';
  544.         case 'n': return '\n';
  545.         case 'r': return '\r';
  546.         case 't': return '\t';
  547.  
  548. #if __STDC__
  549.         case 'a': return '\a';
  550.         case 'v': return '\v';
  551. #else
  552.         case 'a': return '\007';
  553.         case 'v': return '\013';
  554. #endif
  555.  
  556.         case '0':
  557.         case '1':
  558.         case '2':
  559.         case '3':
  560.         case '4':
  561.         case '5':
  562.         case '6':
  563.         case '7':
  564.         case '8':
  565.         case '9':
  566.             { /* \<octal> */
  567.             int sptr = 1;
  568.  
  569.             while ( isascii( array[sptr] ) &&
  570.                 isdigit( array[sptr] ) )
  571.                 /* Don't increment inside loop control
  572.                  * because if isdigit() is a macro it might
  573.                  * expand into multiple increments ...
  574.                  */
  575.                 ++sptr;
  576.  
  577.             c = array[sptr];
  578.             array[sptr] = '\0';
  579.  
  580.             esc_char = otoi( array + 1 );
  581.  
  582.             array[sptr] = c;
  583.  
  584.             return esc_char;
  585.             }
  586.  
  587.         case 'x':
  588.             { /* \x<hex> */
  589.             int sptr = 2;
  590.  
  591.             while ( isascii( array[sptr] ) &&
  592.                 isxdigit( (char) array[sptr] ) )
  593.                 /* Don't increment inside loop control
  594.                  * because if isdigit() is a macro it might
  595.                  * expand into multiple increments ...
  596.                  */
  597.                 ++sptr;
  598.  
  599.             c = array[sptr];
  600.             array[sptr] = '\0';
  601.  
  602.             esc_char = htoi( array + 2 );
  603.  
  604.             array[sptr] = c;
  605.  
  606.             return esc_char;
  607.             }
  608.  
  609.         default:
  610.             return array[1];
  611.         }
  612.     }
  613.  
  614.  
  615. /* otoi - convert an octal digit string to an integer value */
  616.  
  617. int otoi( str )
  618. Char str[];
  619.     {
  620.     unsigned int result;
  621.  
  622.     (void) sscanf( (char *) str, "%o", &result );
  623.     return result;
  624.     }
  625.  
  626.  
  627. /* out - various flavors of outputing a (possibly formatted) string for the
  628.  *     generated scanner, keeping track of the line count.
  629.  */
  630.  
  631. void out( str )
  632. const char str[];
  633.     {
  634.     fputs( str, stdout );
  635.     out_line_count( str );
  636.     }
  637.  
  638. void out_dec( fmt, n )
  639. const char fmt[];
  640. int n;
  641.     {
  642.     printf( fmt, n );
  643.     out_line_count( fmt );
  644.     }
  645.  
  646. void out_dec2( fmt, n1, n2 )
  647. const char fmt[];
  648. int n1, n2;
  649.     {
  650.     printf( fmt, n1, n2 );
  651.     out_line_count( fmt );
  652.     }
  653.  
  654. void out_hex( fmt, x )
  655. const char fmt[];
  656. unsigned int x;
  657.     {
  658.     printf( fmt, x );
  659.     out_line_count( fmt );
  660.     }
  661.  
  662. void out_line_count( str )
  663. const char str[];
  664.     {
  665.     register int i;
  666.  
  667.     for ( i = 0; str[i]; ++i )
  668.         if ( str[i] == '\n' )
  669.             ++out_linenum;
  670.     }
  671.  
  672. void out_str( fmt, str )
  673. const char fmt[], str[];
  674.     {
  675.     printf( fmt, str );
  676.     out_line_count( fmt );
  677.     out_line_count( str );
  678.     }
  679.  
  680. void out_str3( fmt, s1, s2, s3 )
  681. const char fmt[], s1[], s2[], s3[];
  682.     {
  683.     printf( fmt, s1, s2, s3 );
  684.     out_line_count( fmt );
  685.     out_line_count( s1 );
  686.     out_line_count( s2 );
  687.     out_line_count( s3 );
  688.     }
  689.  
  690. void out_str_dec( fmt, str, n )
  691. const char fmt[], str[];
  692. int n;
  693.     {
  694.     printf( fmt, str, n );
  695.     out_line_count( fmt );
  696.     out_line_count( str );
  697.     }
  698.  
  699. void outc( c )
  700. int c;
  701.     {
  702.     putc( c, stdout );
  703.  
  704.     if ( c == '\n' )
  705.         ++out_linenum;
  706.     }
  707.  
  708. void outn( str )
  709. const char str[];
  710.     {
  711.     puts( str );
  712.     out_line_count( str );
  713.     ++out_linenum;
  714.     }
  715.  
  716.  
  717. /* readable_form - return the the human-readable form of a character
  718.  *
  719.  * The returned string is in static storage.
  720.  */
  721.  
  722. char *readable_form( c )
  723. register int c;
  724.     {
  725.     static char rform[10];
  726.  
  727.     if ( (c >= 0 && c < 32) || c >= 127 )
  728.         {
  729.         switch ( c )
  730.             {
  731.             case '\b': return "\\b";
  732.             case '\f': return "\\f";
  733.             case '\n': return "\\n";
  734.             case '\r': return "\\r";
  735.             case '\t': return "\\t";
  736.  
  737. #if __STDC__
  738.             case '\a': return "\\a";
  739.             case '\v': return "\\v";
  740. #endif
  741.  
  742.             default:
  743.                 (void) sprintf( rform, "\\%.3o",
  744.                         (unsigned int) c );
  745.                 return rform;
  746.             }
  747.         }
  748.  
  749.     else if ( c == ' ' )
  750.         return "' '";
  751.  
  752.     else
  753.         {
  754.         rform[0] = c;
  755.         rform[1] = '\0';
  756.  
  757.         return rform;
  758.         }
  759.     }
  760.  
  761.  
  762. /* reallocate_array - increase the size of a dynamic array */
  763.  
  764. void *reallocate_array( array, size, element_size )
  765. void *array;
  766. int size;
  767. size_t element_size;
  768.     {
  769.     register void *new_array;
  770.     size_t num_bytes = element_size * size;
  771.  
  772.     new_array = flex_realloc( array, num_bytes );
  773.     if ( ! new_array )
  774.         flexfatal( _( "attempt to increase array size failed" ) );
  775.  
  776.     return new_array;
  777.     }
  778.  
  779.  
  780. /* skelout - write out one section of the skeleton file
  781.  *
  782.  * Description
  783.  *    Copies skelfile or skel array to stdout until a line beginning with
  784.  *    "%%" or EOF is found.
  785.  */
  786. void skelout()
  787.     {
  788.     char buf_storage[MAXLINE];
  789.     char *buf = buf_storage;
  790.     int do_copy = 1;
  791.  
  792.     /* Loop pulling lines either from the skelfile, if we're using
  793.      * one, or from the skel[] array.
  794.      */
  795.     while ( skelfile ?
  796.         (fgets( buf, MAXLINE, skelfile ) != NULL) :
  797.         ((buf = (char *) skel[skel_ind++]) != 0) )
  798.         { /* copy from skel array */
  799.         if ( buf[0] == '%' )
  800.             { /* control line */
  801.             switch ( buf[1] )
  802.                 {
  803.                 case '%':
  804.                     return;
  805.  
  806.                 case '+':
  807.                     do_copy = C_plus_plus;
  808.                     break;
  809.  
  810.                 case '-':
  811.                     do_copy = ! C_plus_plus;
  812.                     break;
  813.  
  814.                 case '*':
  815.                     do_copy = 1;
  816.                     break;
  817.  
  818.                 default:
  819.                     flexfatal(
  820.                     _( "bad line in skeleton file" ) );
  821.                 }
  822.             }
  823.  
  824.         else if ( do_copy )
  825.             {
  826.             if ( skelfile )
  827.                 /* Skeleton file reads include final
  828.                  * newline, skel[] array does not.
  829.                  */
  830.                 out( buf );
  831.             else
  832.                 outn( buf );
  833.             }
  834.         }
  835.     }
  836.  
  837.  
  838. /* transition_struct_out - output a yy_trans_info structure
  839.  *
  840.  * outputs the yy_trans_info structure with the two elements, element_v and
  841.  * element_n.  Formats the output with spaces and carriage returns.
  842.  */
  843.  
  844. void transition_struct_out( element_v, element_n )
  845. int element_v, element_n;
  846.     {
  847.     out_dec2( " {%4d,%4d },", element_v, element_n );
  848.  
  849.     datapos += TRANS_STRUCT_PRINT_LENGTH;
  850.  
  851.     if ( datapos >= 79 - TRANS_STRUCT_PRINT_LENGTH )
  852.         {
  853.         outc( '\n' );
  854.  
  855.         if ( ++dataline % 10 == 0 )
  856.             outc( '\n' );
  857.  
  858.         datapos = 0;
  859.         }
  860.     }
  861.  
  862.  
  863. /* The following is only needed when building flex's parser using certain
  864.  * broken versions of bison.
  865.  */
  866. void *yy_flex_xmalloc( size )
  867. int size;
  868.     {
  869.     void *result = flex_alloc( (size_t) size );
  870.  
  871.     if ( ! result  )
  872.         flexfatal(
  873.             _( "memory allocation failed in yy_flex_xmalloc()" ) );
  874.  
  875.     return result;
  876.     }
  877.  
  878.  
  879. /* zero_out - set a region of memory to 0
  880.  *
  881.  * Sets region_ptr[0] through region_ptr[size_in_bytes - 1] to zero.
  882.  */
  883.  
  884. void zero_out( region_ptr, size_in_bytes )
  885. char *region_ptr;
  886. size_t size_in_bytes;
  887.     {
  888.     register char *rp, *rp_end;
  889.  
  890.     rp = region_ptr;
  891.     rp_end = region_ptr + size_in_bytes;
  892.  
  893.     while ( rp < rp_end )
  894.         *rp++ = 0;
  895.     }
  896.